home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 001-025 / disk_004 / kermit / send.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  7KB  |  340 lines
  1. /*    @(#)send.c    1.1    1/26/85    */
  2.  
  3. #include "kermit.h"
  4.  
  5. static char sinit ();
  6. static char sfile ();
  7.  
  8.  
  9. VOID Send (argv)
  10. char *argv[];
  11. {
  12.     extern int optind;
  13.     
  14.     DBUG_ENTER ("send");
  15.     DBUG_2 ("send", "begin send attempt");
  16.     filnam = argv[optind];
  17.     if (filnam == NULL) {
  18.     Usage ();
  19.     }
  20.     filelist = &argv[optind+1];
  21.     if (sendsw () == FALSE) {
  22.     (VOID) printf ("Send failed.\n");
  23.     } else {
  24.     (VOID) printf ("OK\n");
  25.     }
  26.     DBUG_VOID_RETURN;
  27. }
  28.  
  29.  
  30. /*
  31.  *    s e n d s w
  32.  *
  33.  *    Sendsw is the state table switcher for sending
  34.  *    files.  It loops until either it finishes, or
  35.  *    an error is encountered.  The routines called by
  36.  *    sendsw are responsible for changing the state.
  37.  */
  38.  
  39. sendsw ()
  40. {
  41.     DBUG_ENTER ("sendsw");
  42.     state = 'S';
  43.     numtry = 0;
  44.     DBUG_2 ("states", "state S set");
  45.     while (TRUE) {
  46.     DBUG_3 ("states", "state %c found", state);
  47.     switch (state) {
  48.         case 'D':                 /* Data-Send state */
  49.         state = sdata ();
  50.         break;
  51.         case 'F':                /* File-Send */
  52.         state = sfile ();
  53.         break;
  54.         case 'Z':                 /* End-of-File */
  55.         state = seof ();
  56.         break;
  57.         case 'S':                /* Send-Init */
  58.         state = sinit ();
  59.         break;
  60.         case 'B':                /* Break-Send */
  61.         state = sbreak ();
  62.         break;
  63.         case 'C':                /* Complete */
  64.         DBUG_RETURN (TRUE);
  65.         case 'A':                 /* Abort */
  66.         DBUG_RETURN (FALSE);
  67.         default:                 /* Unknown, abort */
  68.         DBUG_RETURN (FALSE);
  69.     }
  70.     }
  71. }
  72.  
  73. /*
  74.  *    s i n i t
  75.  */
  76.  
  77. static char sinit ()
  78. {
  79.     int num;
  80.     int len;
  81.     register char newstate;
  82.  
  83.     DBUG_ENTER ("sinit");
  84.     DBUG_2 ("sinit", "begin init attempt");
  85.     if (numtry++ > MAXTRY) {
  86.     DBUG_3 ("tries", "%d tries", numtry - 1);
  87.     newstate = 'A';
  88.     } else {
  89.     spar (packet);
  90.     DBUG_3 ("n", "packet number %d", n);
  91.     spack ('S', n, 6, packet);
  92.     switch (rpack (&len, &num, recpkt)) {
  93.         case 'N':
  94.         DBUG_2 ("nak", "got N packet");
  95.         if (n != num--) {
  96.             newstate = state;
  97.             break;
  98.         }
  99.         case 'Y':
  100.         DBUG_2 ("ack", "got Y packet");
  101.         if (n != num) {
  102.             newstate = state;
  103.             break;
  104.         }
  105.         rpar (recpkt);            /* Get the init info */
  106.         if (eol == 0) {            /* check and set defaults */
  107.             eol = '\n';
  108.         }
  109.         if (quote == 0) {
  110.             quote = '#';
  111.         }
  112.         numtry = 0;            /* reset try counter */
  113.         n = (n + 1) % 64;
  114.         DBUG_3 ("files", "open file %s", filnam);
  115.         fd = open (filnam, 0, 0777);
  116.         if (fd < 0) {
  117.             newstate = 'A';
  118.         } else {
  119.             if (host) {
  120.             (VOID) printf ("Sending %s\n", filnam);
  121.             }
  122.             newstate = 'F';
  123.         }
  124.         break;
  125.         case FALSE: 
  126.         newstate = state;
  127.         break;
  128.         default: 
  129.         newstate = 'A';
  130.         break;
  131.     }
  132.     }
  133.     DBUG_3 ("states", "new state %c", newstate);
  134.     DBUG_RETURN (newstate);
  135. }
  136.  
  137.  
  138.  
  139. /*
  140.  *    s f i l e
  141.  */
  142.  
  143. static char sfile ()
  144. {
  145.     int num;
  146.     int len;
  147.     register char newstate;
  148.  
  149.     DBUG_ENTER ("sfile");
  150.     DBUG_2 ("sfile", "begin send file attempt");
  151.     if (numtry++ > MAXTRY) {
  152.     DBUG_3 ("tries", "%d tries", numtry - 1);
  153.     newstate = 'A';
  154.     } else {
  155.     for (len = 0; filnam[len] != '\0'; len++);    /* count the length */
  156.     len++;
  157.     spack ('F', n, len, filnam);            /* send an 'F' pkt */
  158.     switch (rpack (&len, &num, recpkt)) {
  159.         case 'N':                     /* NAK */
  160.         DBUG_2 ("nak", "got N packet");
  161.         if (n != num--) {
  162.             newstate = state;
  163.             break;
  164.         }
  165.         case 'Y':                     /* ACK */
  166.         DBUG_2 ("ack", "got Y packet");
  167.         if (n != num) {                /* Wrong ACK, fail */
  168.             newstate = state;
  169.         } else {
  170.             numtry = 0;
  171.             n = (n + 1) % 64;
  172.             size = bufill (packet);
  173.             newstate = 'D';
  174.         }
  175.         break;
  176.         case FALSE: 
  177.         newstate = state;
  178.         break;
  179.         default: 
  180.         newstate = 'A';
  181.         break;
  182.     }
  183.     }
  184.     DBUG_3 ("states", "new state %c", newstate);
  185.     DBUG_RETURN (newstate);
  186. }
  187.  
  188.  
  189. /*
  190.  *    s d a t a 
  191.  */
  192.  
  193. sdata ()
  194. {
  195.     int num;
  196.     int len;
  197.     register int newstate;
  198.  
  199.     DBUG_ENTER ("sdata");
  200.     if (numtry++ > MAXTRY) {            /* If too many tries, abort */
  201.     newstate = 'A';
  202.     } else {
  203.     spack ('D', n, size, packet);        /* send a 'D' packet */
  204.     switch (rpack (&len, &num, recpkt)) {    /* What was the reply */
  205.         case 'N':                 /* NAK */
  206.         DBUG_2 ("nak", "got N packet");
  207.         if (n != num--) {
  208.             newstate = state;
  209.             break;
  210.         }
  211.         case 'Y':                 /* ACK */
  212.         DBUG_2 ("ack", "got Y packet");
  213.         if (n != num) {            /* Wrong ACK, fail */
  214.             newstate = state;
  215.             break;
  216.         }
  217.         numtry = 0;            /* rest try counter */
  218.         n = (n + 1) % 64;
  219.         if ((size = bufill (packet)) == EOF) {
  220.             newstate = 'Z';
  221.         } else {
  222.             newstate = 'D';
  223.         }
  224.         break;
  225.         case FALSE: 
  226.         newstate = state;
  227.         break;
  228.         default: 
  229.         newstate = 'A';
  230.         break;
  231.     }
  232.     }
  233.     DBUG_3 ("states", "new state %c", newstate);
  234.     DBUG_RETURN (newstate);
  235. }
  236.  
  237.  
  238. /*
  239.  *    s e o f
  240.  */
  241.  
  242. seof ()
  243. {
  244.     int num;
  245.     int len;
  246.     register int newstate;
  247.  
  248.     DBUG_ENTER ("seof");
  249.     DBUG_2 ("eof", "begin seof");
  250.     if (numtry++ > MAXTRY) {
  251.     DBUG_3 ("tries", "%d tries", numtry - 1);
  252.     newstate = 'A';
  253.     } else {
  254.     spack ('Z', n, 0, packet);        /* Send a 'Z' packet */
  255.     DBUG_2 ("packets", "Z packet sent");
  256.     switch (rpack (&len, &num, recpkt)) {    /* What was the reply? */
  257.         case 'N':                 /* NAK */
  258.         DBUG_2 ("nak", "got N packet");
  259.         if (n != num--) {
  260.             newstate = state;
  261.             break;
  262.         }
  263.         case 'Y':                 /* ACK */
  264.         DBUG_2 ("ack", "got Y packet");
  265.         if (n != num) {            /* if wrong ACK, fail */
  266.             newstate = state;
  267.             break;
  268.         }
  269.         numtry = 0;            /* reset try counter */
  270.     /*        n = (n+1)%64; */
  271.         DBUG_3 ("files", "closing file %s", filnam);
  272.         (VOID) close (fd);        /* close the input file */
  273.         DBUG_2 ("files", "getting next file");
  274.         if (gnxtfl () == FALSE) {    /* No more files go? */
  275.             n = (n + 1) % 64;
  276.             newstate = 'B';
  277.         } else {
  278.             DBUG_3 ("files", "new file is %s", filnam);
  279.             newstate = 'S';
  280.         }
  281.         break;
  282.         case FALSE: 
  283.         newstate = state;
  284.         break;
  285.         default: 
  286.         newstate = 'A';
  287.         break;
  288.     }
  289.     }
  290.     DBUG_3 ("states", "new state %c", newstate);
  291.     DBUG_RETURN (newstate);
  292. }
  293.  
  294.  
  295. /*
  296.  *    s b r e a k
  297.  */
  298.  
  299. sbreak ()
  300. {
  301.     int num;
  302.     int len;
  303.     register int newstate;
  304.  
  305.     DBUG_ENTER ("sbreak");
  306.     DBUG_2 ("break", "begin break transmission");
  307.     if (numtry++ > MAXTRY) {            /* If too many tries abort */
  308.     DBUG_3 ("tries", "%d tries", numtry - 1);
  309.     newstate = 'A';
  310.     } else {
  311.     spack ('B', n, 0, packet);        /* Send a B packet */
  312.     switch (rpack (&len, &num, recpkt)) {    /* What was the reply? */
  313.         case 'N':                 /* NAK */
  314.         DBUG_2 ("nak", "got N packet");
  315.         if (n != num--) {
  316.             newstate = state;
  317.             break;
  318.         }
  319.         case 'Y':                 /* ACK */
  320.         DBUG_2 ("ack", "got Y packet");
  321.         if (n != num) {
  322.             newstate = state;
  323.         } else {
  324.             numtry = 0;            /* reset try counter */
  325.             n = (n + 1) % 64;        /* and bump packet count */
  326.             newstate = 'C';
  327.         }
  328.         break;
  329.         case FALSE: 
  330.         newstate = state;
  331.         break;
  332.         default: 
  333.         newstate = 'A';
  334.         break;
  335.     }
  336.     }
  337.     DBUG_3 ("states", "new state %c", newstate);
  338.     DBUG_RETURN (newstate);
  339. }
  340.